package com.chart.web.controller.chart;

import com.alibaba.fastjson.JSONObject;
import com.chart.chart.domian.ChartConfigs;
import com.chart.chart.domian.vo.ChartSmartVo;
import com.chart.common.utils.ChartDataUtils;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.springframework.util.ObjectUtils;

import java.util.*;

/**
 * 图表工具类
 *
 * @author 罗继全
 * 2024/7/26 11:08
 */
public class ChartDataProcessorUtils {

    public static List<List<String>> extractDataFromList(List<Map<String, Object>> dataList) {
        // 提取数据的方法
        List<List<String>> getData = new ArrayList<>();
        for (Map<String, Object> map : dataList) {
            List<String> row = new ArrayList<>();
            for (Object value : map.values()) {
                row.add(value.toString());
            }
            getData.add(row);
        }
        return getData;
    }

    public static void processChartData(List<List<String>> getData, List<String> xList, List<String> yList, List<List<String>> dataList) {
        // 处理数据，提取x轴和y轴的数据
        for (int i = 0; i < getData.size(); i++) {
            if (!ObjectUtils.isEmpty(getData.get(i)) && !getData.get(i).equals("")) {
                if (i == 0) {
                    List<String> list = getData.get(i);
                    for (int j = 0; j < list.size(); j++) {
                        if (!ObjectUtils.isEmpty(list.get(j)) && !list.get(j).equals("")) {
                            xList.add(list.get(j));
                        }
                    }
                } else {
                    String y = getData.get(i).get(0);
                    if (!ObjectUtils.isEmpty(y) && !y.equals("")) {
                        yList.add(y);
                    }
                    getData.get(i).remove(0);
                    dataList.add(getData.get(i));
                }
            }
        }
    }



    public static double[] getMinMaxValues(List<List<String>> dataList) {
        // 遍历 dataList 获取最小值和最大值
        double minV = Double.MAX_VALUE;
        double maxV = Double.MIN_VALUE;
        for (List<String> row : dataList) {
            for (String value : row) {
                if (!ObjectUtils.isEmpty(value) && !value.equals("")) {
                    try {
                        double num = Double.parseDouble(value);
                        if (num < minV) {
                            minV = num;
                        }
                        if (num > maxV) {
                            maxV = num;
                        }
                    } catch (NumberFormatException e) {
                        // 忽略无法解析为数字的值
                        continue;
                    }
                }
            }
        }
        return new double[]{minV, maxV};
    }

    public static List<List<Object>> getNewDataList(List<String> xList, List<String> yList, List<List<String>> dataList) {
        // 处理新的数据列表
        List<List<Object>> newDataList = new ArrayList<>();
        xList.remove(0);
        for (int i = 0; i < xList.size(); i++) {
            String x = xList.get(i);
            for (int j = 0; j < yList.size(); j++) {
                String s = dataList.get(j).get(i);
                if (!ObjectUtils.isEmpty(s) && !s.equals("")) {
                    String y = yList.get(j);
                    List<Object> cellList = new ArrayList<>();
                    cellList.add(x);
                    cellList.add(y);
                    cellList.add(Double.parseDouble(s));
                    newDataList.add(cellList);
                }
            }
        }
        return newDataList;
    }

    public static void updateChartConfiguration(JsonNode chartValueJson, List<List<Object>> newDataList, double minV, double maxV, List<String> xList, List<String> yList, ObjectMapper objectMapper) throws Exception {
        // 更新visualMap
        ArrayNode visualMapArray = (ArrayNode) chartValueJson.path("visualMap");


        if (visualMapArray.size() > 0) {
            JsonNode firstVisualMap = visualMapArray.get(0);
            if (firstVisualMap instanceof ObjectNode) {
                ObjectNode visualMapObject = (ObjectNode) firstVisualMap;

                // 修改 min 和 max
                visualMapObject.put("min", minV);
                visualMapObject.put("max", maxV);

                // 如果有 range 属性，修改 range 中的数值
                JsonNode rangeNode = visualMapObject.path("range");
                if (rangeNode.isArray()) {
                    ArrayNode rangeArray = (ArrayNode) rangeNode;
                    if (rangeArray.size() == 2) {
                        // 确保 range 数组有两个值，分别为最小值和最大值
                        rangeArray.set(0, objectMapper.valueToTree(minV));
                        rangeArray.set(1, objectMapper.valueToTree(maxV));
                    } else {
                        // 如果 range 数组不存在或大小不符合预期，可以重新设置为新的 minV 和 maxV
                        rangeArray.removeAll();  // 清空现有 range 数组
                        rangeArray.add(objectMapper.valueToTree(minV));
                        rangeArray.add(objectMapper.valueToTree(maxV));
                    }
                } else {
                    // 如果 range 不存在，创建一个新的 range 数组
                    ArrayNode newRangeArray = visualMapObject.putArray("range");
                    newRangeArray.add(objectMapper.valueToTree(minV));
                    newRangeArray.add(objectMapper.valueToTree(maxV));
                }
            }
        }


        // 更新series.data
        ArrayNode seriesArrayUpdated = (ArrayNode) chartValueJson.path("series");
        for (JsonNode seriesNode : seriesArrayUpdated) {
            if (seriesNode.has("data")) {
                seriesNode = (ObjectNode) seriesNode;
                ((ObjectNode) seriesNode).set("data", objectMapper.valueToTree(newDataList));
            }
        }

        // 更新xAxis
        if (chartValueJson.has("xAxis")) {
            ArrayNode xAxisArray = (ArrayNode) chartValueJson.path("xAxis");
            for (JsonNode xAxisNode : xAxisArray) {
                ((ObjectNode) xAxisNode).set("data", objectMapper.valueToTree(xList));
            }
        }
        // 更新yAxis
        if (chartValueJson.has("yAxis")) {
            ArrayNode yAxisArray = (ArrayNode) chartValueJson.path("yAxis");
            for (JsonNode yAxisNode : yAxisArray) {
                ((ObjectNode) yAxisNode).set("data", objectMapper.valueToTree(yList));
            }
        }
    }







    public static void updateChartConfiguration16(JsonNode chartValueJson, List<List<Object>> newDataList, double minV, double maxV, List<String> xList, List<String> yList, ObjectMapper objectMapper) throws Exception {
        // 更新visualMap
        ArrayNode visualMapArray = (ArrayNode) chartValueJson.path("visualMap");

        if (visualMapArray.size() > 0) {
            JsonNode firstVisualMap = visualMapArray.get(0);
            if (firstVisualMap instanceof ObjectNode) {
                ObjectNode visualMapObject = (ObjectNode) firstVisualMap;

                // 修改 min 和 max
                visualMapObject.put("min", minV);
                visualMapObject.put("max", maxV);

                // 如果有 range 属性，修改 range 中的数值
                JsonNode rangeNode = visualMapObject.path("range");
                if (rangeNode.isArray()) {
                    ArrayNode rangeArray = (ArrayNode) rangeNode;
                    if (rangeArray.size() == 2) {
                        // 确保 range 数组有两个值，分别为最小值和最大值
                        rangeArray.set(0, objectMapper.valueToTree(minV));
                        rangeArray.set(1, objectMapper.valueToTree(maxV));
                    } else {
                        // 如果 range 数组不存在或大小不符合预期，可以重新设置为新的 minV 和 maxV
                        rangeArray.removeAll();  // 清空现有 range 数组
                        rangeArray.add(objectMapper.valueToTree(minV));
                        rangeArray.add(objectMapper.valueToTree(maxV));
                    }
                } else {
                    // 如果 range 不存在，创建一个新的 range 数组
                    ArrayNode newRangeArray = visualMapObject.putArray("range");
                    newRangeArray.add(objectMapper.valueToTree(minV));
                    newRangeArray.add(objectMapper.valueToTree(maxV));
                }
            }
        }


        // 更新series.data
        ArrayNode seriesArrayUpdated = (ArrayNode) chartValueJson.path("series");
        for (JsonNode seriesNode : seriesArrayUpdated) {
            if (seriesNode.has("data")) {
                seriesNode = (ObjectNode) seriesNode;
                ((ObjectNode) seriesNode).set("data", objectMapper.valueToTree(newDataList));
            }
        }

        // 更新xAxis
        if (chartValueJson.has("xAxis")) {
            ArrayNode xAxisArray = (ArrayNode) chartValueJson.path("xAxis");
            for (JsonNode xAxisNode : xAxisArray) {
                ((ObjectNode) xAxisNode).set("data", objectMapper.valueToTree(xList));
            }
        }
        // 更新yAxis
        if (chartValueJson.has("yAxis")) {
            ArrayNode yAxisArray = (ArrayNode) chartValueJson.path("yAxis");
            for (JsonNode yAxisNode : yAxisArray) {
                ((ObjectNode) yAxisNode).set("data", objectMapper.valueToTree(yList));
            }
        }
    }






    public static void updateChartConfigurations(
            JsonNode chartValueJson,
            List<List<Object>> newDataList,
            double minV,
            double maxV,
            List<String> xList,
            List<String> yList,
            ObjectMapper objectMapper
    ) throws Exception {
        // 这里假设 colDataSum 和 rowDataSum 是根据 newDataList 生成的
        List<List<Object>> colDataSum = generateColDataSum(newDataList);
        List<List<Object>> rowDataSum = generateRowDataSum(newDataList);

        // 更新 visualMap
        ArrayNode visualMapArray = (ArrayNode) chartValueJson.path("visualMap");

        if (visualMapArray.size() > 0) {
            JsonNode firstVisualMap = visualMapArray.get(0);
            if (firstVisualMap instanceof ObjectNode) {
                ObjectNode visualMapObject = (ObjectNode) firstVisualMap;

                // 修改 min 和 max
                visualMapObject.put("min", minV);
                visualMapObject.put("max", maxV);

                // 如果有 range 属性，修改 range 中的数值
                JsonNode rangeNode = visualMapObject.path("range");
                if (rangeNode.isArray()) {
                    ArrayNode rangeArray = (ArrayNode) rangeNode;
                    if (rangeArray.size() == 2) {
                        // 确保 range 数组有两个值，分别为最小值和最大值
                        rangeArray.set(0, objectMapper.valueToTree(minV));
                        rangeArray.set(1, objectMapper.valueToTree(maxV));
                    } else {
                        // 如果 range 数组不存在或大小不符合预期，可以重新设置为新的 minV 和 maxV
                        rangeArray.removeAll();  // 清空现有 range 数组
                        rangeArray.add(objectMapper.valueToTree(minV));
                        rangeArray.add(objectMapper.valueToTree(maxV));
                    }
                } else {
                    // 如果 range 不存在，创建一个新的 range 数组
                    ArrayNode newRangeArray = visualMapObject.putArray("range");
                    newRangeArray.add(objectMapper.valueToTree(minV));
                    newRangeArray.add(objectMapper.valueToTree(maxV));
                }
            }
        }

        // 更新 series.data
        ArrayNode seriesArrayUpdated = (ArrayNode) chartValueJson.path("series");
        List<JSONObject> series = new ArrayList<>();

        // 将 JsonNode 转换为 List<JSONObject> 以便于操作
        for (JsonNode node : seriesArrayUpdated) {
            series.add(objectMapper.treeToValue(node, JSONObject.class));
        }

        // 更新 series 数据
        for (int i = 0; i < series.size(); i++) {
            JSONObject jsonObject1 = series.get(i);
            if (i == 0) {
                jsonObject1.put("data", newDataList);
            } else if (i == 1) {
                jsonObject1.put("data", colDataSum);
            } else {
                jsonObject1.put("data", rowDataSum);
            }
        }

        // 更新 xAxis
        if (chartValueJson.has("xAxis")) {
            ArrayNode xAxisArray = (ArrayNode) chartValueJson.path("xAxis");
            for (JsonNode xAxisNode : xAxisArray) {
                ((ObjectNode) xAxisNode).set("data", objectMapper.valueToTree(xList));
            }
        }

        // 更新 yAxis
        if (chartValueJson.has("yAxis")) {
            ArrayNode yAxisArray = (ArrayNode) chartValueJson.path("yAxis");
            for (JsonNode yAxisNode : yAxisArray) {
                ((ObjectNode) yAxisNode).set("data", objectMapper.valueToTree(yList));
            }
        }
    }

    // 假设你有这两个方法来生成列和行的汇总数据
    private static List<List<Object>> generateColDataSum(List<List<Object>> newDataList) {
        // 实现列汇总逻辑
        return new ArrayList<>(); // 返回实际的列数据汇总
    }

    private static List<List<Object>> generateRowDataSum(List<List<Object>> newDataList) {
        // 实现行汇总逻辑
        return new ArrayList<>(); // 返回实际的行数据汇总
    }









    /*public static void updateChartConfigurations(JsonNode chartValueJson, List<List<Object>> newDataList, double minV, double maxV, List<String> xList, List<String> yList, ObjectMapper objectMapper) throws Exception {
        // 更新visualMap
        ArrayNode visualMapArray = (ArrayNode) chartValueJson.path("visualMap");


        if (visualMapArray.size() > 0) {
            JsonNode firstVisualMap = visualMapArray.get(0);
            if (firstVisualMap instanceof ObjectNode) {
                ObjectNode visualMapObject = (ObjectNode) firstVisualMap;

                // 修改 min 和 max
                visualMapObject.put("min", minV);
                visualMapObject.put("max", maxV);

                // 如果有 range 属性，修改 range 中的数值
                JsonNode rangeNode = visualMapObject.path("range");
                if (rangeNode.isArray()) {
                    ArrayNode rangeArray = (ArrayNode) rangeNode;
                    if (rangeArray.size() == 2) {
                        // 确保 range 数组有两个值，分别为最小值和最大值
                        rangeArray.set(0, objectMapper.valueToTree(minV));
                        rangeArray.set(1, objectMapper.valueToTree(maxV));
                    } else {
                        // 如果 range 数组不存在或大小不符合预期，可以重新设置为新的 minV 和 maxV
                        rangeArray.removeAll();  // 清空现有 range 数组
                        rangeArray.add(objectMapper.valueToTree(minV));
                        rangeArray.add(objectMapper.valueToTree(maxV));
                    }
                } else {
                    // 如果 range 不存在，创建一个新的 range 数组
                    ArrayNode newRangeArray = visualMapObject.putArray("range");
                    newRangeArray.add(objectMapper.valueToTree(minV));
                    newRangeArray.add(objectMapper.valueToTree(maxV));
                }
            }
        }



        // 更新series.data
        ArrayNode seriesArrayUpdated = (ArrayNode) chartValueJson.path("series");
        for (JsonNode seriesNode : seriesArrayUpdated) {
            if (seriesNode.has("data")) {
                seriesNode = (ObjectNode) seriesNode;
                ((ObjectNode) seriesNode).set("data", objectMapper.valueToTree(newDataList));
            }
        }




        // 更新xAxis
        if (chartValueJson.has("xAxis")) {
            ArrayNode xAxisArray = (ArrayNode) chartValueJson.path("xAxis");
            for (JsonNode xAxisNode : xAxisArray) {
                ((ObjectNode) xAxisNode).set("data", objectMapper.valueToTree(xList));
            }
        }
        // 更新yAxis
        if (chartValueJson.has("yAxis")) {
            ArrayNode yAxisArray = (ArrayNode) chartValueJson.path("yAxis");
            for (JsonNode yAxisNode : yAxisArray) {
                ((ObjectNode) yAxisNode).set("data", objectMapper.valueToTree(yList));
            }
        }
    }*/

    // 更新dataset节点
    public static ArrayNode updateDatasetSources(ArrayNode dataset, List<List<String>> lists, ObjectMapper objectMapper) {
        for (int i = 0; i < dataset.size(); i++) {
            ArrayNode sourceArray = (ArrayNode) dataset.get(i).get("source");
            for (int j = 0; j < lists.size(); j++) {
                ArrayNode newSource = objectMapper.createArrayNode();
                for (String value : lists.get(j)) {
                    newSource.add(value);
                }
                sourceArray.set(j, newSource);
            }
        }
        return dataset;
    }

    // 更新legend节点数据
    public static void updateLegendData(JsonNode legend, List<List<String>> lists) {
        if (legend.has("data")) {
            ArrayNode legendData = (ArrayNode) legend.get("data");
            legendData.removeAll();
            for (String name : lists.get(0)) {
                legendData.add(name);
            }
        }
    }


    // 处理series节点
    public static void processSeries(ArrayNode seriesArray, List<List<String>> lists) {
        // 移除集合中第一个对象的第一个元素
        if (!lists.isEmpty() && !lists.get(0).isEmpty()) {
            lists.get(0).remove(0);
        }

        // 获取series字段并删除其余对象
        if (seriesArray.size() > 1) {
            while (seriesArray.size() > 1) {
                seriesArray.remove(1);
            }
        }

        // 计算第一个对象剩余元素数量
        int firstObjectRemainingElements = lists.isEmpty() ? 0 : lists.get(0).size();

        // 复制series的第一个对象
        JsonNode firstSeriesObject = seriesArray.get(0);
        for (int i = 1; i < firstObjectRemainingElements; i++) {
            seriesArray.add(firstSeriesObject.deepCopy());
        }

        // 处理 datasetIndex 字段
        for (int i = 0; i < seriesArray.size(); i++) {
            ObjectNode seriesObject = (ObjectNode) seriesArray.get(i);
            seriesObject.put("datasetIndex", i);
        }

        // 更新series中每个对象的name字段
        for (int i = 0; i < firstObjectRemainingElements; i++) {
            ((ObjectNode) seriesArray.get(i)).put("name", lists.get(0).get(i));
        }
    }


    public static JsonNode processChartValue(String chartValue, List<List<String>> lists) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode chartValueJson = objectMapper.readTree(chartValue);

        // 获取dataset节点并替换source节点
        ArrayNode dataset = (ArrayNode) chartValueJson.path("dataset");
        for (JsonNode node : dataset) {
            if (node.has("source")) {
                ((ObjectNode) node).set("source", objectMapper.valueToTree(lists));
                break;
            }
        }

        // 移除集合中第一个对象的第一个元素
        if (!lists.isEmpty() && !lists.get(0).isEmpty()) {
            lists.get(0).remove(0);
        }

        // 获取series节点并替换name字段
        ArrayNode series = (ArrayNode) chartValueJson.path("series");
        List<String> names = lists.isEmpty() ? Collections.emptyList() : lists.get(0);
        for (int i = 0; i < series.size() && i < names.size(); i++) {
            JsonNode seriesItem = series.get(i);
            if (seriesItem.has("name")) {
                ((ObjectNode) seriesItem).put("name", names.get(i));
            }
        }

        // 获取legend节点并更新data
        JsonNode legend = chartValueJson.path("legend");
        ChartDataUtils.updateLegendData(legend, lists);

        return chartValueJson;
    }

    public static ChartSmartVo createChartSmartVo(ChartConfigs configs, String updatedChartValue) {
        ChartSmartVo chartSmartVo = new ChartSmartVo();
        chartSmartVo.setConfigId(configs.getId()); // 假设ChartConfigs有getId方法
        chartSmartVo.setConfigName(configs.getConfigName()); // 假设ChartConfigs有getName方法
        chartSmartVo.setConfigValue(updatedChartValue);
        chartSmartVo.setChartTypeId(configs.getChartTypeId());
        return chartSmartVo;
    }


}
